package com.shujia.day06.learn;

import com.shujia.day05.Cat;

class Animal1{
    int age = 1;
    public void eat(){
        System.out.println("动物需要进食");
    }

    public void sleep(){
        System.out.println("动物需要休息...");
    }


}

class Dog1 extends Animal1{
    int age = 10;

    public void eat(){
        System.out.println("狗爱吃骨头");
    }

    // 子类独有，父类引用不能进行调用
    public void call(){
        System.out.println("狗会汪汪汪...");
    }


//    public void sleep(){
//        System.out.println("狗可以趴着睡...");
//    }

    public static void info(){
        System.out.println("这是一个动物");
    }
}

class Cat1 extends Animal1{
    public void eat(){
        System.out.println("猫爱吃鱼");
    }


    public void call(){
        System.out.println("猫会喵喵喵...");
    }
}

public class Code02Demo {
    public static void main(String[] args) {




        /*
            在上述的继承关系中，Animal实际上应该是一个抽象的物种类，而Dog和Cat类应该是一个具体的物种类 动物是一个概念的集合，
                既然是一个概念的集合，按理说 应该可以去通过概念类调用其对应的方法

            动物： 猫 狗 猪...
            水果： 苹果 梨子 桃子 ...

            多态：
                多态表示的就是一个多种状态

            多态的前提：
                1.要有继承关系
                2.需要有方法的重写,不重写也可以，但是调用的是父类中的对应方法
                3.父类引用指向子类对象

            多态的特点：
                成员方法： 通过多态形式访问成员方法，编译看左，运行看右
                成员变量： 通过多态形式访问成员变量，编译看左，运行看左
                静态方法： 通过多态形式访问静态方法，编译看左，运行看左

            多态的好处
                    提高了程序的维护性(由继承保证)
                    提高了程序的扩展性(由多态保证)

         */

        Dog1 dog1 = new Dog1();
        dog1.eat();
        dog1.sleep();

        //  new Dog1(); 创建了一个子类的对象  并将其堆中的内存地址传递给了 Animal1 animal1 => 父类引用指向子类对象
        Animal1 animal1 = new Dog1(); // 多态
        animal1.eat(); // 实际上是通过子类对象进行调用其对应的方法
        animal1.sleep();

        System.out.println(animal1.age);
//        Cat1 cat1 = new Dog1();

//        animal1.info();

//        animal1.call(); // 编译看左边  Animal1中并没有call方法，该方法为Dog所的独有的


        // 将猫的对象给Animal
        animal1 = new Cat1();
        animal1.eat();

        // 创建使用eat的方法并对其进行调用

        Animal1 animal = new Animal1();
        Dog1 dog = new Dog1();
        Cat1 cat = new Cat1();

//        Animal1 dog = new Dog1();  对函数的调用实际上就是左边所给定的模式
//        Animal1 cat = new Cat1();

        useEat(animal);
        useEat(dog);
        useEat(cat);

        Code03AnimalTool.useEat(animal);
        Code03AnimalTool.useEat(dog);
        Code03AnimalTool.useEat(cat);

    }

    // 对于传入的参数，可以设置成父类的类型及变量 在调用时，根据多态的特性，可以传入子类的对象
    public static void useEat(Animal1 animal1){
        // 调用其eat方法
        animal1.eat();
    }
}
